home *** CD-ROM | disk | FTP | other *** search
/ The Atari Compendium / The Atari Compendium (Toad Computers) (1994).iso / files / umich / tex / tex29 / sttexsrc.zoo / src / def.c < prev    next >
Encoding:
C/C++ Source or Header  |  1988-03-13  |  23.6 KB  |  1,015 lines
  1.  
  2. /*
  3.  * @(#)def.c 2.7 EPA
  4.  *
  5.  * Copyright 1987,1988 Pat J Monardo
  6.  *
  7.  * Redistribution of this file is permitted through
  8.  * the specifications in the file COPYING.
  9.  *
  10.  * 
  11.  */
  12.  
  13. #include "tex.h"
  14. #include "eqstack.h"
  15. #include "evalstack.h"
  16. #include "hash.h"
  17. #include "token.h"
  18. #include "scan.h"
  19. #include "tokenstack.h"
  20. #include "expand.h"
  21. #include "box.h"
  22. #include "boxlists.h"
  23. #include "tokenlists.h"
  24. #include "file.h"
  25. #include "tfm.h"
  26. #include "dvi.h"
  27. #include "page.h"
  28. #include "def.h"
  29.  
  30. hword   after_token;
  31. bool    long_help_seen;
  32. val     mag_set;
  33.  
  34. #define glob    (a >= 4)
  35.  
  36. #define def(code, type, value) \
  37.     {if (glob) \
  38.         geq_define(code, type, value); \
  39.     else eq_define(code, type, value);}
  40.  
  41. #define word_def(code, value) \
  42.     {if (glob) \
  43.         geq_word_define(code, value); \
  44.     else eq_word_define(code, value);}
  45.  
  46. get_r_token ()
  47. {
  48. restart:
  49.     do get_token();
  50.     while (cur_tok == SPACE_TOKEN);
  51.     if (cur_cs == 0 || cur_cs > FROZEN_CONTROL_SEQUENCE) {
  52.         print_err("Missing control sequence inserted");
  53.         help_missing_cs();
  54.         if (cur_cs == 0) back_input();
  55.         cur_tok = CS_TOKEN_FLAG + FROZEN_PROTECTION;
  56.         ins_error();
  57.         goto restart;
  58.     }
  59. }
  60.  
  61. prefixed_command ()
  62. {
  63.     int     a;
  64.     bool    e;
  65.     fnt     f;
  66.     int     j;
  67.     int     k;
  68.     val     n;
  69.     ptr     p;
  70.     ptr     q;
  71.     ptr     r;
  72.  
  73.     a = 0;
  74.     while (cur_cmd == PREFIX) {
  75.         if (!odd(a / cur_chr))
  76.             a += cur_chr;
  77.         get_nbrx_token();
  78.         if (cur_cmd <= MAX_NON_PREFIXED_COMMAND) {
  79.             print_err("You can't use a prefix with `");
  80.             print_cmd_chr(cur_cmd, cur_chr);
  81.             print("'");
  82.             help_prefix();
  83.             back_error();
  84.             return;
  85.         }
  86.     }
  87.  
  88.     if (cur_cmd != DEF && a % 4 != 0) {
  89.         print_err("You can't use `");
  90.         print_esc("long");
  91.         print("' or `");
  92.         print_esc("outer");
  93.         print("' with `");
  94.         print_cmd_chr(cur_cmd, cur_chr);
  95.         print("'");
  96.         help_pref();
  97.         error();
  98.     }
  99.  
  100.     if (global_defs != 0) {
  101.         if (global_defs < 0) {
  102.             if (glob) a -= 4;
  103.         } else {
  104.             if (!glob) a += 4;
  105.         }
  106.     }
  107.  
  108.     switch (cur_cmd)
  109.     {
  110.     case SET_FONT:
  111.         def(CUR_FONT_LOC, DATA, cur_chr);
  112.         break;
  113.  
  114.     case DEF:
  115.         if (odd(cur_chr) && !glob && global_defs >= 0)
  116.             a += 4;
  117.         e = (cur_chr >= 2);
  118.         get_r_token();
  119.         p = cur_cs;
  120.         scan_toks(TRUE, e);
  121.         def(p, CALL + (a % 4), def_ref);
  122.         break;
  123.  
  124.     case LET:
  125.         n = cur_chr;
  126.         get_r_token();
  127.         p = cur_cs;
  128.         if (n == NORMAL) {
  129.             do  get_token();
  130.             while (cur_cmd == SPACER);
  131.             if (cur_tok == OTHER_TOKEN + '=') {
  132.                 get_token();
  133.                 if (cur_cmd == SPACER)
  134.                     get_token();
  135.             }
  136.         } else {
  137.             get_token();
  138.             q = cur_tok;
  139.             get_token();
  140.             back_input();
  141.             cur_tok = q;
  142.             back_input();
  143.         }
  144.         if (cur_cmd >= CALL)
  145.             add_token_ref(cur_chr);
  146.         def(p, cur_cmd, cur_chr);
  147.         break;
  148.     
  149.     case SHORTHAND_DEF:
  150.         n = cur_chr;
  151.         get_r_token();
  152.         p = cur_cs; 
  153.         def(p, RELAX, 256);
  154.         scan_optional_equals();
  155.         switch ((hword) n)
  156.         {
  157.         case CHAR_DEF_CODE:
  158.             scan_char_num();
  159.             def(p, CHAR_GIVEN, (hword) cur_val);
  160.             break;
  161.  
  162.         case MATH_CHAR_DEF_CODE:
  163.             scan_fifteen_bit_int();
  164.             def(p, MATH_GIVEN, (hword) cur_val);
  165.             break;
  166.  
  167.         default:
  168.             scan_eight_bit_int();
  169.             switch ((hword) n)
  170.             {
  171.             case COUNT_DEF_CODE:
  172.                 def(p, ASSIGN_INT, (hword) (COUNT_BASE + cur_val));
  173.                 break;
  174.  
  175.             case DIMEN_DEF_CODE:
  176.                 def(p, ASSIGN_DIMEN, (hword) (SCALED_BASE + cur_val));
  177.                 break;
  178.  
  179.             case SKIP_DEF_CODE:
  180.                 def(p, ASSIGN_GLUE, (hword) (SKIP_BASE + cur_val));
  181.                 break;
  182.  
  183.             case MU_SKIP_DEF_CODE:
  184.                 def(p, ASSIGN_MU_GLUE, (hword) (MU_SKIP_BASE + cur_val));
  185.                 break;
  186.  
  187.             case TOKS_DEF_CODE:
  188.                 def(p, ASSIGN_TOKS, (hword) (TOKS_BASE + cur_val));
  189.                 break;
  190.             }
  191.             break;
  192.         }
  193.         break;
  194.  
  195.     case READ_TO_CS:
  196.         scan_int();
  197.         n = (int) cur_val;
  198.         if (!scan_keyword("to")) {
  199.             print_err("Missing `to' inserted");
  200.             help_read_to();
  201.             error();
  202.         }
  203.         get_r_token();
  204.         p = cur_cs;
  205.         read_toks(n, p);
  206.         def(p, CALL, (hword) cur_val);
  207.         break;
  208.     
  209.     case TOKS_REGISTER:
  210.     case ASSIGN_TOKS:
  211.         q = cur_cs;
  212.         if (cur_cmd == TOKS_REGISTER) {
  213.             scan_eight_bit_int();
  214.             p = TOKS_BASE + cur_val;
  215.         } else p = cur_chr;
  216.         scan_optional_equals();
  217.         get_nbrx_token();
  218.         if (cur_cmd != LEFT_BRACE) {
  219.             if (cur_cmd == TOKS_REGISTER) {
  220.                 scan_eight_bit_int();
  221.                 cur_cmd = ASSIGN_TOKS;
  222.                 cur_chr = TOKS_BASE + cur_val;
  223.             }
  224.             if (cur_cmd == ASSIGN_TOKS) {
  225.                 q = equiv(cur_chr);
  226.                 if (q == NULL) {
  227.                     def(p, UNDEFINED_CS, NULL);
  228.                 } else {    
  229.                     add_token_ref(q);
  230.                     def(p, CALL, q);
  231.                 }
  232.                 break;
  233.             }
  234.         }
  235.         back_input();
  236.         cur_cs = q;
  237.         q = scan_toks(FALSE, FALSE);
  238.         if (token_link(def_ref) == NULL) {
  239.             def(p, UNDEFINED_CS, NULL);
  240.             free_token(def_ref);
  241.         } else {
  242.             if (p == OUTPUT_ROUTINE_LOC) {
  243.                 token_link(q) = new_token();
  244.                 q = token_link(q);
  245.                 token(q) = RIGHT_BRACE_TOKEN + '}';
  246.                 q = new_token();
  247.                 token(q) = LEFT_BRACE_TOKEN + '{';
  248.                 token_link(q) = token_link(def_ref);
  249.                 token_link(def_ref) = q;
  250.             }
  251.             def(p, CALL, def_ref);
  252.         }
  253.         break;
  254.  
  255.     case ASSIGN_INT:
  256.         p = cur_chr;
  257.         scan_optional_equals();
  258.         scan_int();
  259.         word_def(p, cur_val); 
  260.         break;
  261.     
  262.     case ASSIGN_DIMEN:
  263.         p = cur_chr;
  264.         scan_optional_equals();
  265.         scan_normal_dimen();
  266.         word_def(p, cur_val); 
  267.         break;
  268.     
  269.     case ASSIGN_GLUE:
  270.     case ASSIGN_MU_GLUE:
  271.         p = cur_chr;
  272.         n = cur_cmd;
  273.         scan_optional_equals();
  274.         if (n == ASSIGN_MU_GLUE)
  275.             scan_glue(MU_VAL);
  276.         else scan_glue(GLUE_VAL);
  277.         trap_zero_glue();
  278.         def(p, GLUE_REF, (ptr) cur_val); 
  279.         break;
  280.     
  281.     case DEF_CODE:
  282.         if (cur_chr == CAT_CODE_BASE)
  283.             n = MAX_CHAR_CODE;
  284.         else if (cur_chr == MATH_CODE_BASE)
  285.             n = 0100000;
  286.         else if (cur_chr == SF_CODE_BASE)
  287.             n = 077777;
  288.         else if (cur_chr == DEL_CODE_BASE)
  289.             n = 077777777;
  290.         else n = 127;
  291.         p = cur_chr;
  292.         scan_seven_bit_int();
  293.         p += cur_val;
  294.         scan_optional_equals();
  295.         scan_int(); 
  296.         if (cur_val < 0 && p < DEL_CODE_BASE || cur_val > n) {
  297.             print_err("Invalid code (");
  298.             print_val(cur_val);
  299.             if (p < DEL_CODE_BASE)
  300.                 print("), should be in the range 0..");
  301.             else print("), should be at most ");
  302.             print_val(n);
  303.             help_code();
  304.             error();
  305.             cur_val = 0;
  306.         }
  307.         if (p < MATH_CODE_BASE) {
  308.             def(p, DATA, (hword) cur_val);
  309.         } else if (p < DEL_CODE_BASE) {
  310.             def(p, DATA, (hword) hi(cur_val));
  311.         } else word_def(p, cur_val);
  312.         break;
  313.     
  314.     case DEF_FAMILY:
  315.         p = cur_chr;
  316.         scan_four_bit_int();
  317.         p += cur_val;
  318.         scan_optional_equals();
  319.         scan_font_ident();
  320.         def(p, DATA, (hword) cur_val);
  321.         break;
  322.  
  323.     case REGISTER:
  324.     case ADVANCE:
  325.     case MULTIPLY:
  326.     case DIVIDE:
  327.         do_register_command(a);
  328.         break;
  329.     
  330.     case SET_BOX:
  331.         scan_eight_bit_int();
  332.         if (glob)
  333.             saved(0) = BOX_FLAG + 256 + cur_val;
  334.         else saved(0) = BOX_FLAG + cur_val;
  335.         scan_optional_equals();
  336.         scan_box();
  337.         break;
  338.     
  339.     case SET_AUX:
  340.         alter_aux();
  341.         break;
  342.  
  343.     case SET_PREV_GRAF:
  344.         alter_prev_graf();
  345.         break;
  346.         
  347.     case SET_PAGE_DIMEN:
  348.         alter_page_so_far();
  349.         break;
  350.  
  351.     case SET_PAGE_INT:
  352.         alter_integer();
  353.         break;
  354.  
  355.     case SET_BOX_DIMEN:
  356.         alter_box_dimen();
  357.         break;
  358.  
  359.     case SET_SHAPE:
  360.         scan_optional_equals();
  361.         scan_int();
  362.         n = cur_val;
  363.         if (n <= 0)
  364.             p = NULL;
  365.         else {
  366.             p = get_node(2 * n + 1);
  367.             info(p) = n;
  368.             for (j = 1; j <= n; incr(j)) {
  369.                 scan_normal_dimen();
  370.                 mem[p + 2 * j - 1].sc = cur_val;
  371.                 scan_normal_dimen();
  372.                 mem[p + 2 * j].sc = cur_val;
  373.             }
  374.         }
  375.         def(PAR_SHAPE_LOC, SHAPE_REF, p);
  376.         break;
  377.     
  378.     case HYPH_DATA:
  379. #ifdef  INIT
  380.         if (cur_chr == 1) 
  381.             new_patterns();
  382. #else
  383.         if (cur_chr == 1) {
  384.             print_err("Patterns can only be loaded by INITEX");
  385.             error();
  386.         }
  387. #endif
  388.         else new_hyph_exceptions();
  389.         break;
  390.     
  391.     case ASSIGN_FONT_DIMEN:
  392.         find_font_dimen(TRUE);
  393.         k = cur_val;
  394.         scan_optional_equals();
  395.         scan_normal_dimen();
  396.         font_info[k].sc = cur_val;
  397.         break;
  398.     
  399.     case ASSIGN_FONT_INT:
  400.         n = cur_chr;
  401.         scan_font_ident();
  402.         f = cur_val;
  403.         scan_optional_equals();
  404.         scan_int(); 
  405.         if (n == 0)
  406.             hyphen_char[f] = cur_val;
  407.         else skew_char[f] = cur_val;
  408.         break;
  409.  
  410.     case DEF_FONT:
  411.         new_font(a);
  412.         break;
  413.  
  414.     case SET_INTERACTION:
  415.         new_interaction();
  416.         break;
  417.  
  418.     default:
  419.         confusion("prefix");
  420.         break;
  421.     }
  422.     if (after_token != 0) {
  423.         cur_tok = after_token;
  424.         back_input();
  425.         after_token = 0;
  426.     }
  427. } 
  428.  
  429. trap_zero_glue()
  430. {
  431.     if (width(cur_val) == 0 &&
  432.         stretch(cur_val) == 0 &&
  433.         shrink(cur_val) == 0) {
  434.         add_glue_ref(zero_glue);
  435.         delete_glue_ref(cur_val);
  436.         cur_val = zero_glue;
  437.     }
  438. }
  439.  
  440. do_register_command (a)
  441.     int     a;
  442. {
  443.     ptr     l;
  444.     ptr     p;
  445.     ptr     q;
  446.     ptr     r;
  447.     ptr     s;
  448.  
  449.     q = cur_cmd;
  450.     if (q != REGISTER) {
  451.         get_x_token();
  452.         if (cur_cmd >= ASSIGN_INT && cur_cmd <= ASSIGN_MU_GLUE) {
  453.             l = cur_chr;
  454.             p = cur_cmd - ASSIGN_INT;
  455.             goto found;
  456.         }
  457.         if (cur_cmd != REGISTER) {
  458.             print_err("You can't use `");
  459.             print_cmd_chr(cur_cmd, cur_chr);
  460.             print("' after ");
  461.             print_cmd_chr(q, 0);
  462.             help_register();
  463.             error();
  464.             return;
  465.         }
  466.     }
  467.     p = cur_chr;
  468.     scan_eight_bit_int();
  469.     switch (p) 
  470.     {
  471.     case INT_VAL:
  472.         l = cur_val + COUNT_BASE;
  473.         break;
  474.  
  475.     case DIMEN_VAL:
  476.         l = cur_val + SCALED_BASE;
  477.         break;
  478.         
  479.     case GLUE_VAL:
  480.         l = cur_val + SKIP_BASE;
  481.         break;
  482.         
  483.     case MU_VAL:
  484.         l = cur_val + MU_SKIP_BASE;
  485.         break;
  486.     }
  487.  
  488. found:
  489.     if (q == REGISTER)
  490.         scan_optional_equals();
  491.     else scan_keyword("by");
  492.     arith_error = FALSE;
  493.     if (q < MULTIPLY)  {
  494.         if (p < GLUE_VAL) {
  495.             if (p == INT_VAL)
  496.                 scan_int();
  497.             else scan_normal_dimen();
  498.             if (q == ADVANCE)
  499.                 cur_val += eqtb[l].i;
  500.         } else {
  501.             scan_glue(p);
  502.             if (q == ADVANCE) {
  503.                 q = new_spec(cur_val);
  504.                 r = equiv(l);
  505.                 delete_glue_ref(cur_val);
  506.                 width(q) += width(r);
  507.                 if (stretch(q) == 0)
  508.                     stretch_order(q) = NORMAL;
  509.                 if (stretch_order(q) == stretch_order(r)) {
  510.                     stretch(q) += stretch(r);
  511.                 } else if (stretch_order(q) < stretch_order(r) && stretch(r)) {
  512.                     stretch(q) = stretch(r);
  513.                     stretch_order(q) = stretch_order(r);
  514.                 }
  515.                 if (shrink(q) == 0)
  516.                     shrink_order(q) = NORMAL;
  517.                 if (shrink_order(q) == shrink_order(r)) {
  518.                     shrink(q) += shrink(r);
  519.                 } else if (shrink_order(q) < shrink_order(r) && shrink(r)) {
  520.                     shrink(q) = shrink(r); 
  521.                     shrink_order(q) = shrink_order(r);
  522.                 }
  523.                 cur_val = q;
  524.             }
  525.         }
  526.     } else {
  527.         scan_int();
  528.         if (p < GLUE_VAL) {
  529.             if (q == MULTIPLY)
  530.                 cur_val = nx_plus_y(eqtb[l].i, cur_val, 0L);
  531.             else cur_val = x_over_n(eqtb[l].i, cur_val);
  532.         } else {
  533.             s = equiv(l);
  534.             r = new_spec(s);
  535.             if (q == MULTIPLY) {
  536.                 width(r) = nx_plus_y(width(s), cur_val, 0L);
  537.                 stretch(r) = nx_plus_y(stretch(s), cur_val, 0L);
  538.                 shrink(r) = nx_plus_y(shrink(s), cur_val, 0L);
  539.             } else {
  540.                 width(r) = x_over_n(width(s), cur_val);
  541.                 stretch(r) = x_over_n(stretch(s), cur_val);
  542.                 shrink(r) = x_over_n(shrink(s), cur_val);
  543.             }
  544.             cur_val = r;
  545.         }
  546.     }
  547.     if (arith_error) {
  548.         print_err("Arithmetic overflow");
  549.         help_overflow();
  550.         error();
  551.         return;
  552.     }
  553.     if (p < GLUE_VAL) {
  554.         word_def(l, cur_val);
  555.     } else {
  556.         trap_zero_glue();
  557.         def(l, GLUE_REF, (ptr) cur_val);
  558.     }
  559. }
  560.  
  561. alter_aux()
  562. {
  563.     hword   c;
  564.  
  565.     if (cur_chr != abs(mode)) {
  566.         report_illegal_case();
  567.     } else {
  568.         c = cur_chr;
  569.         scan_optional_equals();
  570.         if (c == VMODE)  {
  571.             scan_normal_dimen();
  572.             prev_depth = cur_val;
  573.         } else {
  574.             scan_int();
  575.             if (cur_val <= 0 || cur_val > 32767) {
  576.                 print_err("Bad space factor");
  577.                 help_space_factor();
  578.                 int_error(cur_val);
  579.             } else {
  580.                 space_factor = cur_val;
  581.             }
  582.         }
  583.     }
  584. }
  585.  
  586. alter_prev_graf ()
  587. {
  588.     ptr     p;
  589.  
  590.     nest[nest_ptr] = cur_list;
  591.     p = nest_ptr;
  592.     while (abs(nest[p].mode_field) != VMODE)    
  593.         decr(p);
  594.     scan_optional_equals();
  595.     scan_int();
  596.     if (cur_val < 0) {
  597.         print_err("Bad ");
  598.         print_esc("prevgraf");
  599.         help_prevgraf();
  600.         int_error(cur_val);
  601.     } else {
  602.         nest[p].pg_field = cur_val;
  603.         cur_list = nest[nest_ptr];
  604.     }
  605. }
  606.  
  607. alter_page_so_far ()
  608. {
  609.     hword   c;
  610.  
  611.     c = cur_chr;
  612.     scan_optional_equals(); 
  613.     scan_normal_dimen();
  614.     page_so_far[c] = cur_val;
  615. }
  616.  
  617. alter_integer ()
  618. {
  619.     hword   c;
  620.     
  621.     c = cur_chr;
  622.     scan_optional_equals();
  623.     scan_int();
  624.     if (c == 0)
  625.         dead_cycles = cur_val;
  626.     else insert_penalties = cur_val;
  627. }
  628.  
  629. alter_box_dimen ()
  630. {
  631.     hword   b;
  632.     hword   c;
  633.     
  634.     c = cur_chr;
  635.     scan_eight_bit_int();
  636.     b = cur_val; 
  637.     scan_optional_equals();
  638.     scan_normal_dimen();
  639.     if (box(b) != NULL)
  640.         mem[box(b) + c].sc = cur_val;
  641. }
  642.  
  643. new_font (a)
  644.     int     a;
  645. {
  646.     fnt     f;
  647.     scal    s;
  648.     str     t;
  649.     ptr     u;
  650.     int     old_setting;
  651.  
  652.     if (job_name == 0)
  653.         open_log_file();
  654.     get_r_token();
  655.     u = cur_cs;
  656.     if (u >= HASH_BASE) {
  657.         t = text(u);
  658.     } else if (u >= SINGLE_BASE) {
  659.         if (u == NULL_CS)
  660.             t = make_str_given("FONT");
  661.         else t = u - SINGLE_BASE;
  662.     } else {
  663.         old_setting = selector;
  664.         selector = NEW_STRING;
  665.         print("FONT");
  666.         print_str(u - ACTIVE_BASE);
  667.         selector = old_setting;
  668.         str_room(1);
  669.         t = make_str();
  670.     }
  671.     def(u, SET_FONT, null_font);
  672.     scan_optional_equals();
  673.     scan_file_name();
  674.     name_in_progress = TRUE;
  675.     if (scan_keyword("at")) {
  676.         scan_normal_dimen();
  677.         s = cur_val;
  678.         if (s <= 0 || s >= 01000000000) {
  679.             print_err("Improper `at' size (");
  680.             print_scaled(s);
  681.             print("pt), replaced by 10pt");
  682.             help_font_at();
  683.             error();
  684.             s = 10 * UNITY;
  685.         }
  686.     } else if (scan_keyword("scaled")) {
  687.         scan_int();
  688.         s = -cur_val;
  689.         if (cur_val <= 0 || cur_val > 32768) {
  690.             print_err("Illegal magnification has been changed to 1000");
  691.             help_font_magnification();
  692.             int_error(cur_val);
  693.             s = -1000;
  694.         }
  695.     } else {
  696.         s = -1000;
  697.     }
  698.     name_in_progress = FALSE;
  699.     for (f = FONT_BASE + 1; f <= font_ptr; f++) {
  700.         if (str_eq_str(font_name[f], cur_name) &&
  701.             str_eq_str(font_area[f], cur_area)) {
  702.             if (s > 0) {
  703.                 if (s == font_size[f])
  704.                     goto common_end;
  705.             } else if (font_size[f] == xn_over_d(font_dsize[f], -s, 1000L)) {
  706.                 goto common_end;
  707.             }
  708.         }
  709.     }
  710.     f = read_font_info(u, cur_name, cur_area, s);
  711.  
  712. common_end:
  713.     equiv(u) = f;
  714.     eqtb[FONT_ID_BASE + f] = eqtb[u];
  715.     font_id_text(f) = t;
  716. }
  717.  
  718. prepare_mag ()
  719. {
  720.     if (mag_set > 0 && mag != mag_set) {
  721.         print_err("Incompatible magnification (");
  722.         print_val(mag);
  723.         print(");");
  724.         print_nl(" the previous value will be retained");
  725.         help_mag();
  726.         int_error(mag_set);
  727.         geq_word_define((ptr) INT_BASE + MAG_CODE, mag_set);
  728.     }
  729.     if (mag <= 0 || mag > 32768) {
  730.         print_err("Illegal magnification has been changed to 1000");
  731.         help_ill_mag();
  732.         int_error(mag);
  733.         geq_word_define((ptr) INT_BASE + MAG_CODE, 1000L);
  734.     }
  735.     mag_set = mag;
  736. }
  737.         
  738. new_interaction ()
  739. {
  740.     print_ln();
  741.     interaction = cur_chr;
  742.     if (interaction == BATCH_MODE)
  743.         selector = NO_PRINT;
  744.     else selector = TERM_ONLY;
  745.     if (job_name != 0)
  746.         selector += 2;
  747. }
  748.  
  749. do_assignments ()
  750. {
  751.     loop {
  752.         get_nbrx_token();
  753.         if (cur_cmd <= MAX_NON_PREFIXED_COMMAND)
  754.             break;
  755.         prefixed_command();
  756.     }
  757. }
  758.  
  759. clopen_stream ()
  760. {   
  761.     int     c;
  762.     int     n;
  763.  
  764.     c = cur_chr;
  765.     scan_four_bit_int();
  766.     n = cur_val; 
  767.     if (read_open[n] != CLOSED) {
  768.         a_close(read_file[n]);
  769.         read_open[n] = CLOSED;
  770.     }
  771.     if (c != 0) {
  772.         scan_optional_equals();
  773.         scan_file_name();
  774.         if (cur_ext == null_str)
  775.             cur_ext = str_tex;
  776.         pack_cur_name();
  777.         if (read_file[n] = a_open_in())
  778.             read_open[n] = JUST_OPENED;
  779.     }
  780. }
  781.  
  782. issue_message ()
  783. {
  784.     int     c;
  785.     str     s;
  786.     int     old_setting;
  787.  
  788.     c = cur_chr;
  789.     scan_toks(FALSE, TRUE);
  790.     old_setting = selector;
  791.     selector = NEW_STRING;
  792.     token_show(def_ref);
  793.     selector = old_setting;
  794.     flush_list(def_ref);
  795.     str_room(1);
  796.     s = make_str();
  797.     if (c == 0) {
  798.         if (term_offset + length(s) > MAX_PRINT_LINE - 2)
  799.             print_ln();
  800.         else if (term_offset > 0 || file_offset > 0)
  801.             print_char(' ');
  802.         print_str(s);
  803.         update_terminal();
  804.     } else {
  805.         print_err("");
  806.         print_str(s);
  807.         if (err_help != NULL)
  808.             use_err_help = TRUE;
  809.         else if (long_help_seen)
  810.             help_err_msg();
  811.         else {
  812.             if (interaction < ERROR_STOP_MODE)
  813.                 long_help_seen = TRUE;
  814.             help_poirot();
  815.         }
  816.         error();
  817.         use_err_help = FALSE;
  818.     }
  819.     flush_string();
  820. }
  821.  
  822. give_err_help ()
  823. {
  824.     token_show(err_help);
  825. }
  826.  
  827. shift_case ()
  828. {
  829.     ptr     b;
  830.     byte    c;
  831.     ptr     p;
  832.     tok     t;
  833.  
  834.     b = cur_chr;
  835.     scan_toks(FALSE, FALSE);
  836.     for (p = token_link(def_ref); p != NULL; p = token_link(p)) {
  837.         t = token(p);
  838.         if (t < CS_TOKEN_FLAG + SINGLE_BASE) {
  839.             if (t >= CS_TOKEN_FLAG)
  840.                 t -= ACTIVE_BASE;
  841.             c = t % 256;
  842.             if (c < 128 && equiv(b + c) != 0)
  843.                 t = 256 * (t / 256) + equiv(b + c);
  844.             if (t >= CS_TOKEN_FLAG)
  845.                 token(p) = t + ACTIVE_BASE;
  846.             else token(p) = t;
  847.         }
  848.     }
  849.     back_list(token_link(def_ref));
  850.     free_token(def_ref);
  851. }
  852.  
  853. show_whatever ()
  854. {
  855.     switch (cur_chr)
  856.     {
  857.     case SHOW_LISTS:
  858.         begin_diagnostic();
  859.         show_activities();
  860.         break;
  861.  
  862.     case SHOW_BOX_CODE:
  863.         scan_eight_bit_int();
  864.         begin_diagnostic();
  865.         print_nl("> \\box");
  866.         print_val(cur_val);
  867.         print_char('=');
  868.         if (box(cur_val) == NULL)
  869.             print("void");
  870.         else show_box(box(cur_val));
  871.         break;
  872.     
  873.     case SHOW_CODE:
  874.         get_token();
  875.         print_nl("> ");
  876.         if (cur_cs != 0) {
  877.             sprint_cs(cur_cs);
  878.             print_char('=');
  879.         }
  880.         print_meaning();
  881.         goto common_end;
  882.         break;
  883.     
  884.     default:
  885.         the_toks();
  886.         print_nl("> ");
  887.         token_show(temp_toks);
  888.         flush_list(token_link(temp_toks));
  889.         goto common_end;
  890.         break;
  891.     }
  892.     end_diagnostic(TRUE);
  893.     print_err("OK");
  894.     if (selector == TERM_AND_LOG && tracing_online <= 0) {
  895.         selector = TERM_ONLY;
  896.         print(" (see the transcript file)");
  897.         selector = TERM_AND_LOG;
  898.     }
  899.  
  900. common_end:
  901.     if (interaction < ERROR_STOP_MODE) {
  902.         help0();
  903.         decr(error_count);
  904.     } else if (tracing_online > 0)
  905.         help_show_online();
  906.     else help_show();
  907.     error();
  908. }
  909.  
  910. /*
  911.  *  Help text
  912.  */
  913.  
  914. help_missing_cs ()
  915. {
  916.     help5("Please don't say `\\def cs{...}', say `\\def\\cs{...}'.",
  917.     "I've inserted an inaccessible control sequence so that your",
  918.     "definition will be completed without mixing me up too badly.",
  919.     "You can recover graciously from this error, if you're",
  920.     "careful; see exercise 27.2 in The TeXbook.");
  921. }
  922.  
  923. help_prefix ()
  924. {
  925.     help1("I'll pretend you didn't say \\long or \\outer or \\global.");
  926. }
  927.  
  928. help_pref ()
  929. {
  930.     help1("I'll pretend you didn't say \\long or \\outer here.");
  931. }
  932.  
  933. help_read_to ()
  934. {
  935.     help2("You should have said `\\read<number> to \\cs'.",
  936.     "I'm going to look for the \\cs now.");
  937. }
  938.  
  939. help_code ()
  940. {
  941.     help1("I'm going to use 0 instead of that illegal code value.");
  942. }
  943.  
  944. help_register ()
  945. {
  946.     help1("I'm forgetting what you said and not changing anything.");
  947. }
  948.  
  949. help_space_factor ()
  950. {
  951.     help1("I allow only values in the range 1..32767 here.");
  952. }
  953.  
  954. help_prevgraf ()
  955. {
  956.     help1("I allow only nonnegative values here.");
  957. }
  958.  
  959. help_overflow ()
  960. {
  961.     help2("I can't carry out that multiplication or division,",
  962.     "since the result is out of range.");
  963. }
  964.  
  965. help_font_at ()
  966. {
  967.     help2("I can only handle fonts at positive sizes that are",
  968.     "less than 2048pt, so I've changed what you said to 10pt.");
  969. }
  970.  
  971. help_font_magnification ()
  972. {
  973.     help1("The magnification ratio must be between 1 and 32768.");
  974. }
  975.  
  976. help_mag()
  977. {
  978.     help2("I can handle only one magnification ratio per job. So I've",
  979.     "reverted to the magnification you used earlier on this run.");
  980. }
  981.  
  982. help_ill_mag ()
  983. {
  984.     help1("The magnification ratio must be between 1 and 32768.");
  985. }
  986.  
  987. help_err_msg ()
  988. {
  989.     help1("(That was another \\errmessage.)");
  990. }
  991.  
  992. help_poirot ()
  993. {
  994.     help4("This error message was generated by an \\errmessage",
  995.     "command, so I can't give any explicit help.",
  996.     "Pretend that you're Hercule Poirot: Examine all clues,",
  997.     "and deduce the truth by order and method.");
  998. }
  999.  
  1000. help_show_online ()
  1001. {
  1002.     help3("This isn't an error message; I'm just \\showing something.",
  1003.     "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1004.     "\\showthe\\count10, \\showbox255, \\showlists).");
  1005. }
  1006.  
  1007. help_show ()
  1008. {
  1009.     help5("This isn't an error message; I'm just \\showing something.",
  1010.     "Type `I\\show...' to show more (e.g., \\show\\cs,",
  1011.     "\\showthe\\count10, \\showbox255, \\showlists).",
  1012.     "And type `I\\tracingonline=1\\show...' to show boxes and",
  1013.     "lists on your terminal as well as in the transcript file.");
  1014. }
  1015.